home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 112 / EnigmaAmiga112CD.iso / dalla rivista / posta / hdsleep.lha / HDSleep / Source / main.c < prev    next >
C/C++ Source or Header  |  1998-06-19  |  17KB  |  739 lines
  1. /*
  2. ** includes
  3. */
  4.  
  5. #include<dos.h>
  6. #include<stdio.h>
  7. #include<string.h>
  8. #include<stdlib.h>
  9. #include<proto/dos.h>
  10. #include<proto/exec.h>
  11. #include<proto/icon.h>
  12. #include<proto/commodities.h>
  13. #include<proto/intuition.h>
  14. #include<proto/gadtools.h>
  15. #include<exec/io.h>
  16. #include<exec/memory.h>
  17. #include<exec/interrupts.h>
  18. #include<exec/execbase.h>
  19. #include<exec/devices.h>
  20. #include<dos/rdargs.h>
  21. #include<devices/timer.h>
  22. #include<devices/scsidisk.h>
  23. #include"hdsleep_rev.h"
  24. #include"gadtools.h"
  25.  
  26. /*
  27. ** version
  28. */
  29.  
  30. char    ver[]=VERSTAG;
  31.  
  32. /*
  33. ** defines
  34. */
  35.  
  36. #define TYPE_RUN 0
  37. #define TYPE_END 1
  38. #define TYPE_SPINUP 2
  39. #define TYPE_SPINDOWN 3
  40. #define TYPE_HOTKEY 4
  41.  
  42. #define TEMPLATE "CX_PRIORITY/N/K,CX_POPKEY/K,CX_POPUP/K,HDSLEEPKEY=SKEY/K,MASTERTIME=MT/N,SLAVETIME=ST/N,WARNING=WARN/S,WARNINGTIMEOUT=WT/N,LOGFILE=L/K,A4000/S,ELSAT/S"
  43. #define ARG_PRIORITY        0
  44. #define ARG_POPKEY            1
  45. #define ARG_POPUP                2
  46. #define ARG_HDSLEEPKEY    3
  47. #define ARG_MASTERTIME    4
  48. #define ARG_SLAVETIME        5
  49. #define ARG_WARNING            6
  50. #define ARG_WARNINGTO        7
  51. #define ARG_LOGFILE            8
  52. #define ARG_A4000                9
  53. #define ARG_ELSAT                10
  54. #define ARG_COUNT                11
  55.  
  56. #define OFF 0
  57. #define ON 1
  58. #define STOPPED 2
  59. #define EVT_POPKEY 1
  60. #define EVT_HOTKEY 2
  61. #define DRV_MASTER 0
  62. #define DRV_SLAVE 1
  63.  
  64. #define    unless(x) if ( !(x) )
  65. #define LEAVE goto exitit
  66.  
  67. ULONG DEF_PRIORITY=0;
  68. char    DEF_POPKEY[]="control alt h";
  69. char    DEF_POPUP2[]="YES";
  70. ULONG DEF_POPUP=1;
  71. char    DEF_HDSLEEPKEY[]="control h";
  72. ULONG DEF_MASTERTIME=360;    // 360 secs == 4 mins
  73. ULONG DEF_SLAVETIME=0;      // 360 secs == 4 mins
  74. ULONG DEF_WARNING=0;
  75. ULONG DEF_WARNINGTO=5;
  76. char DEF_LOGFILE[]="\0";
  77. ULONG DEF_A4000=FALSE;
  78. ULONG DEF_ELSAT=FALSE;
  79.  
  80. /*
  81. ** prototypes
  82. */
  83.  
  84. void    main(int, char **);
  85. void    __saveds __asm MyBeginIO(register __a1 struct IORequest *);
  86. int        AddInt(void);
  87. void    RemInt(void);
  88. void    HandleCxMsg(void);
  89. void    RequestOK(char *);
  90. APTR    BusyWindow(struct Window *);
  91. void    UnbusyWindow(APTR);
  92. void    LogFile(UBYTE,UBYTE);
  93.  
  94. extern struct DiskObject *TTGetOurIcon(struct WBStartup *);
  95. extern void TTFreeOurIcon(struct DiskObject *);
  96. extern char *TTString(struct DiskObject *,char *, char *);
  97. extern LONG TTInt(struct DiskObject *,char *, LONG);
  98. extern int TTBool(struct DiskObject *,char *, BOOL);
  99.  
  100. //extern    void SPrintf(char *,const char *, ...);
  101. extern    void __asm CallBeginIO(register __a1 struct IORequest *);
  102. extern    void __asm HDDriveOff(register __d0 UBYTE);
  103. extern    UBYTE __asm CheckHD(register __d0 UBYTE);
  104.  
  105. /*
  106. ** variables
  107. */
  108.  
  109. extern struct ExecBase *SysBase;
  110. APTR OldBeginIO=NULL;
  111. struct DiskObject *icon=NULL;
  112. struct Library *SCSIBase=NULL;
  113. struct MsgPort *TimerPort=NULL;
  114. struct timerequest TimerReq;
  115. struct IntuiMessage *message;
  116. struct Gadget *gadget;
  117. struct MenuItem *item;
  118. BOOL running=TRUE,timerun=FALSE,POPUP=TRUE;//,SpinUp=FALSE;
  119. ULONG MASTERTIME,SLAVETIME,signals,MasterTime=0,SlaveTime=0,class,code;
  120. ULONG SigWin,WARNING=0,WARNINGTO,ComputerA4000=0,ComputerELSAT=0,Computer=0;
  121. UBYTE MasterHD,SlaveHD;
  122. ULONG BeginIOCounter=0;
  123.  
  124. struct BusyWin
  125. {
  126.     struct Requester Req;
  127.     struct Window *Win;
  128. };
  129.  
  130. /*
  131. ** commodities
  132. */
  133.  
  134. struct NewBroker newbroker=
  135. {
  136.     NB_VERSION,
  137.     "HDSleep",
  138.     "HDSleep v1.5 by Tomasz Muszynski",
  139.     "HD noise saver for Amiga Computers",
  140.     NBU_UNIQUE|NBU_NOTIFY,
  141.     COF_SHOW_HIDE
  142. };
  143.  
  144. struct MsgPort *broker_mp=NULL;
  145. CxObj *broker=NULL, *hdsleepobj, *popkeyobj;
  146. CxMsg *cxmsg;
  147. ULONG msgid, msgtype;
  148. UBYTE hdsleepstr[50],popkeystr[50],logfilestr[108];
  149. struct Unit *MasterUnit=NULL,*SlaveUnit=NULL;
  150.  
  151. /*
  152. ** functions
  153. */
  154.  
  155. void main(int argc,char *argv[])
  156. {
  157.     struct RDArgs *rdargs;
  158.     long *(opts[ARG_COUNT]),arg;
  159.     struct Node *SCSINode;
  160.     struct IORequest SCSIIOReq;
  161.     struct MsgPort *SCSIPort;
  162.  
  163.     if(SysBase->LibNode.lib_Version<39)
  164.     {
  165.         RequestOK("You must have\nAmiga with OS3.0");
  166.         LEAVE;
  167.     }
  168.     MasterHD=FALSE;    // MasterHD=CheckHD(DRV_MASTER);
  169.     SlaveHD=FALSE;    // SlaveHD=CheckHD(DRV_SLAVE);
  170.  
  171.     if(argc!=0)
  172.     {
  173.         opts[ARG_PRIORITY]=&DEF_PRIORITY;
  174.         opts[ARG_POPKEY]=(long *)DEF_POPKEY;
  175.         opts[ARG_POPUP]=(long *)DEF_POPUP2;
  176.         opts[ARG_HDSLEEPKEY]=(long *)DEF_HDSLEEPKEY;
  177.         opts[ARG_MASTERTIME]=&DEF_MASTERTIME;
  178.         opts[ARG_SLAVETIME]=&DEF_SLAVETIME;
  179.         opts[ARG_WARNING]=(long *)DEF_WARNING;
  180.         opts[ARG_WARNINGTO]=&DEF_WARNINGTO;
  181.         opts[ARG_LOGFILE]=(long *)DEF_LOGFILE;
  182.         opts[ARG_A4000]=(long *)DEF_A4000;
  183.         opts[ARG_ELSAT]=(long *)DEF_ELSAT;
  184.  
  185.         if(rdargs=ReadArgs(TEMPLATE,(long *) opts, NULL))
  186.         {
  187.             arg=FindArg(TEMPLATE,"CX_PRIORITY");
  188.             if(arg>-1)
  189.                 newbroker.nb_Pri=*opts[arg];
  190.  
  191.             arg=FindArg(TEMPLATE,"CX_POPUP");
  192.             if(arg>-1)
  193.             {
  194.                 if(!stricmp((char *)opts[arg],"NO")) POPUP=FALSE;
  195.                 if(!stricmp((char *)opts[arg],"FALSE")) POPUP=FALSE;
  196.                 if(!stricmp((char *)opts[arg],"OFF")) POPUP=FALSE;
  197.             }
  198.  
  199.             arg=FindArg(TEMPLATE,"CX_POPKEY");
  200.             if(arg>-1)
  201.                 strcpy(popkeystr,(char *)opts[arg]);
  202.  
  203.             arg=FindArg(TEMPLATE,"HDSLEEPKEY");
  204.             if(arg>-1)
  205.                 strcpy(hdsleepstr,(char *)opts[arg]);
  206.  
  207.             arg=FindArg(TEMPLATE,"MASTERTIME");
  208.             if(arg>-1)
  209.             {
  210.                 MASTERTIME=*opts[arg];
  211.                 if(MASTERTIME) MasterHD=TRUE;
  212.             }
  213.  
  214.             arg=FindArg(TEMPLATE,"SLAVETIME");
  215.             if(arg>-1)
  216.             {
  217.                 SLAVETIME=*opts[arg];
  218.                 if(SLAVETIME) SlaveHD=TRUE;
  219.             }
  220.  
  221.             arg=FindArg(TEMPLATE,"WARNING");
  222.             if(arg>-1)
  223.                 WARNING=(ULONG)opts[arg];
  224.  
  225.             arg=FindArg(TEMPLATE,"WARNINGTIMEOUT");
  226.             if(arg>-1)
  227.                 WARNINGTO=*opts[arg];
  228.  
  229.             arg=FindArg(TEMPLATE,"LOGFILE");
  230.             if(arg>-1)
  231.                 strcpy(logfilestr,(char *)opts[arg]);
  232.  
  233.             arg=FindArg(TEMPLATE,"A4000");
  234.             if(arg>-1)
  235.                 ComputerA4000=(ULONG)opts[arg];
  236.  
  237.             arg=FindArg(TEMPLATE,"ELSAT");
  238.             if(arg>-1)
  239.                 ComputerELSAT=(ULONG)opts[arg];
  240.  
  241.             FreeArgs(rdargs);
  242.         }
  243.         else
  244.         {
  245.             PrintFault(IoErr(),argv[0]);
  246.             LEAVE;
  247.         }
  248.     }
  249.     else
  250.     {
  251.         unless(icon=TTGetOurIcon(WBenchMsg)) icon=GetDiskObject(argv[0]);
  252.         newbroker.nb_Pri=TTInt(icon,"CX_PRIORITY",DEF_PRIORITY);
  253.         strcpy(popkeystr,TTString(icon,"CX_POPKEY",DEF_POPKEY));
  254.         POPUP=TTBool(icon,"CX_POPUP",DEF_POPUP);
  255.         strcpy(hdsleepstr,TTString(icon,"HDSLEEPKEY",DEF_HDSLEEPKEY));
  256.         MASTERTIME=TTInt(icon,"MASTERTIME",DEF_MASTERTIME);
  257.         if(MASTERTIME) MasterHD=TRUE;
  258.         SLAVETIME=TTInt(icon,"SLAVETIME",DEF_SLAVETIME);
  259.         if(SLAVETIME) SlaveHD=TRUE;
  260.         WARNING=TTBool(icon,"WARNING",DEF_WARNING);
  261.         WARNINGTO=TTInt(icon,"WARNINGTIMEOUT",DEF_WARNINGTO);
  262.         strcpy(logfilestr,TTString(icon,"LOGFILE",DEF_LOGFILE));
  263.         ComputerA4000=(ULONG) TTBool(icon,"A4000",DEF_A4000);
  264.         ComputerELSAT=(ULONG) TTBool(icon,"ELSAT",DEF_ELSAT);
  265.         TTFreeOurIcon(icon);
  266.     }
  267.  
  268.     if(ComputerA4000) Computer=1L;
  269.     if(ComputerELSAT) Computer=2L;
  270.  
  271.     if(MASTERTIME==0) MasterHD=FALSE;
  272.     if(SLAVETIME==0) SlaveHD=FALSE;
  273.  
  274.     MasterTime=MASTERTIME;
  275.     SlaveTime=SLAVETIME;
  276.  
  277.     unless(broker_mp=CreateMsgPort()) LEAVE;
  278.     newbroker.nb_Port=broker_mp;
  279.     unless(broker=CxBroker(&newbroker,NULL)) LEAVE;
  280.     unless(hdsleepobj=HotKey(hdsleepstr,broker_mp,EVT_HOTKEY)) LEAVE;
  281.     unless(popkeyobj=HotKey(popkeystr,broker_mp,EVT_POPKEY)) LEAVE;
  282.     AttachCxObj(broker,hdsleepobj);
  283.     if(CxObjError(hdsleepobj)) LEAVE;
  284.     AttachCxObj(broker,popkeyobj);
  285.     if(CxObjError(popkeyobj)) LEAVE;
  286.     ActivateCxObj(broker,1L);
  287.  
  288. // Get scsi.device base address
  289.  
  290.     unless(SCSINode=FindName(&SysBase->DeviceList,ComputerELSAT?"elsat.device":"scsi.device")) LEAVE;
  291.     if(SCSIPort=CreatePort(NULL,0))
  292.     {
  293.         SCSIIOReq.io_Message.mn_ReplyPort=SCSIPort;
  294.         if(OpenDevice(ComputerELSAT?"elsat.device":"scsi.device",0L, &SCSIIOReq,0L)) { DeletePort(SCSIPort); LEAVE; }
  295.         SCSIBase=&SCSIIOReq.io_Device->dd_Library;
  296.         MasterUnit=SCSIIOReq.io_Unit;
  297.         CloseDevice(&SCSIIOReq);
  298.         if(!OpenDevice(ComputerELSAT?"elsat.device":"scsi.device",1L, &SCSIIOReq,0L))
  299.         {
  300.             SlaveUnit=SCSIIOReq.io_Unit;
  301.             CloseDevice(&SCSIIOReq);
  302.         }
  303.         DeletePort(SCSIPort);
  304.     }
  305.     else LEAVE;
  306.  
  307. // Replace BeginIO
  308.  
  309.     Forbid();
  310.     SumLibrary(SCSIBase);
  311.     unless(OldBeginIO=SetFunction(SCSIBase,DEV_BEGINIO,(unsigned long (*)())MyBeginIO)) LEAVE;
  312.     SumLibrary(SCSIBase);
  313.     Permit();
  314.  
  315.     unless(timerun=AddInt()) LEAVE;
  316.  
  317.     SigWin=NULL;
  318.  
  319.     if(POPUP)
  320.     {
  321.         if(!SetupScreen())
  322.         {
  323.             if(!OpenMainWindow())
  324.             {
  325.                 SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  326.                 GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  327.                 GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  328.             }
  329.         }
  330.     }
  331.  
  332.     LogFile(TYPE_RUN,0);
  333.  
  334.     while(running)
  335.     {
  336.         signals=Wait(SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | (1L<<broker_mp->mp_SigBit) | SigWin | 1L<<TimerPort->mp_SigBit);
  337.         if(signals & (1L<<TimerPort->mp_SigBit))
  338.         {
  339.             if(MainWnd)
  340.             {
  341.                 GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  342.                 GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  343.             }
  344. //            if(SpinUp)
  345. //            {
  346. //                LogFile(TYPE_SPINUP,0);
  347. //                SpinUp=FALSE;
  348. //            }
  349.             if(MasterTime>0 && MasterHD)
  350.             {
  351.                 MasterTime--;
  352.                 if(MasterTime==0)
  353.                 {
  354.                     LogFile(TYPE_SPINDOWN,0);
  355.                     MasterTime=0;
  356.                     while(BeginIOCounter>0) Delay(10);
  357.                     if(BeginIOCounter==0) HDDriveOff(DRV_MASTER);
  358.                     if(MainWnd)
  359.                     {
  360.                         CloseMainWindow();
  361.                         CloseDownScreen();
  362.                         SigWin=NULL;
  363.                     }
  364.                 }
  365.             }
  366.             if(SlaveTime>0 && SlaveHD)
  367.             {
  368.                 SlaveTime--;
  369.                 if(SlaveTime==0)
  370.                 {
  371.                     LogFile(TYPE_SPINDOWN,1);
  372.                     SlaveTime=0;
  373.                     while(BeginIOCounter>0) Delay(10);
  374.                     if(BeginIOCounter==0) HDDriveOff(DRV_SLAVE);
  375.                     if(MainWnd)
  376.                     {
  377.                         CloseMainWindow();
  378.                         CloseDownScreen();
  379.                         SigWin=NULL;
  380.                     }
  381.                 }
  382.             }
  383.             TimerReq.tr_time.tv_secs=1;
  384.             TimerReq.tr_time.tv_micro=0;
  385.             SendIO((struct IORequest *) &TimerReq);
  386.             if(WARNING && (SlaveTime==WARNINGTO || MasterTime==WARNINGTO) && !MainWnd)
  387.             {
  388.                 if(!SetupScreen())
  389.                 {
  390.                     if(!OpenMainWindow())
  391.                     {
  392.                         SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  393.                     }
  394.                 }
  395.             }
  396.             if(WARNING && (SlaveTime==WARNINGTO || MasterTime==WARNINGTO) && MainWnd) WindowToFront(MainWnd);
  397.         }
  398.         if(signals & SIGBREAKF_CTRL_C) running=FALSE;
  399.         if(signals & SIGBREAKF_CTRL_D)
  400.         {
  401.             LogFile(TYPE_HOTKEY,0);
  402.             MasterTime=0;
  403.             HDDriveOff(DRV_MASTER);
  404.             SlaveTime=0;
  405.             HDDriveOff(DRV_SLAVE);
  406.         }
  407.         if(signals & SigWin)
  408.         {
  409.             while(message=GT_GetIMsg(MainWnd->UserPort))
  410.             {
  411.                 class=message->Class;
  412.                 code=message->Code;
  413.                 gadget=(struct Gadget *)message->IAddress;
  414.                 GT_ReplyIMsg(message);
  415.                 switch(class)
  416.                 {
  417.                     case IDCMP_CLOSEWINDOW:
  418.                         goto gdhide;
  419.                         break;
  420.                     case IDCMP_MENUPICK:
  421.                         while(code!=MENUNULL) 
  422.                         {
  423.                             item=(struct MenuItem *)ItemAddress(MainMenus,code);
  424.                             switch(ITEMNUM(code))
  425.                             {
  426.                                 case 0: goto gdsleep; break;
  427.                                 case 1: goto gdabort; break;
  428.                                 case 3: RequestOK("HDSleep v1.5\n"\
  429.                                                         "     by     \n"\
  430.                                                         " Thom/Union \n"\
  431.                                                         "            \n"\
  432.                                                         "This program\n"\
  433.                                                         "is  FREEWARE");
  434.                                     break;
  435.                                 case 5: goto gdhide; break;
  436.                                 case 6: goto gdquit; break;
  437.                             }
  438.                             code = item->NextSelect;
  439.                         }
  440.                         break;
  441.                     case IDCMP_VANILLAKEY:
  442.                         switch(code)
  443.                         {
  444.                             case 's':
  445.                             case 'S': goto gdsleep; break;
  446.                             case 'a':
  447.                             case 'A': goto gdabort; break;
  448.                             case 'q':
  449.                             case 'Q': goto gdquit; break;
  450.                         }
  451.                         break;
  452.                     case IDCMP_GADGETUP:
  453.                         switch(gadget->GadgetID)
  454.                         {
  455.                             case GD_SLEEP:
  456. gdsleep:                while(message=(struct IntuiMessage *)GetMsg(MainWnd->UserPort)) ReplyMsg((struct Message *)message);
  457.                                 CloseMainWindow();
  458.                                 CloseDownScreen();
  459.                                 SigWin=NULL;
  460.                                 LogFile(TYPE_HOTKEY,0);
  461.                                 MasterTime=0;
  462.                                 HDDriveOff(DRV_MASTER);
  463.                                 SlaveTime=0;
  464.                                 HDDriveOff(DRV_SLAVE);
  465.                                 goto skip;
  466.                                 break;
  467.                             case GD_ABORT:
  468. gdabort:                MasterTime=MASTERTIME;
  469.                                 SlaveTime=SLAVETIME;
  470. gdhide:                    while(message=(struct IntuiMessage *)GetMsg(MainWnd->UserPort)) ReplyMsg((struct Message *)message);
  471.                                 CloseMainWindow();
  472.                                 CloseDownScreen();
  473.                                 SigWin=NULL;
  474.                                 goto skip;
  475.                                 break;
  476.                             case GD_QUIT:
  477. gdquit:                    running=FALSE;
  478.                                 break;
  479.                         }
  480.                         break;
  481.                 }
  482.             }
  483.         }
  484.         if(signals & (1L<<broker_mp->mp_SigBit)) HandleCxMsg();
  485. skip:;
  486.     }
  487.  
  488. exitit:
  489.     LogFile(TYPE_END,0);
  490.  
  491.     if(MainWnd)
  492.     {
  493.         CloseMainWindow();
  494.         CloseDownScreen();
  495.         SigWin=NULL;
  496.     }
  497.     RemInt();
  498.  
  499.     Forbid();
  500.     SumLibrary(SCSIBase);
  501.     if(OldBeginIO) SetFunction(SCSIBase,DEV_BEGINIO,(unsigned long (*)())OldBeginIO);
  502.     SumLibrary(SCSIBase);
  503.     Permit();
  504.  
  505.     if(broker) DeleteCxObjAll(broker);
  506.     if(broker_mp) DeleteMsgPort(broker_mp);
  507. }
  508.  
  509. void __saveds __asm MyBeginIO(register __a1 struct IORequest *io)
  510. {
  511.     struct SCSICmd *scsi;
  512.  
  513.     BeginIOCounter++;
  514.     switch(io->io_Command)
  515.     {
  516.         case CMD_START:
  517.             break;
  518.         case CMD_STOP:
  519.             break;
  520.         case HD_SCSICMD:
  521.             scsi=(struct SCSICmd *)((struct IOStdReq *)io)->io_Data;
  522.             if(scsi->scsi_Flags==1) break;
  523.         default:
  524.             if(io->io_Unit==MasterUnit) MasterTime=MASTERTIME;
  525.             if(io->io_Unit==SlaveUnit) SlaveTime=SLAVETIME;
  526.             break;
  527.     }    
  528.     CallBeginIO(io);
  529.     BeginIOCounter--;
  530. //    SpinUp=TRUE;
  531. }
  532.  
  533. int AddInt()
  534. {
  535.     if(TimerPort=CreatePort(NULL,0L))
  536.     {
  537.         if(!OpenDevice(TIMERNAME,UNIT_MICROHZ,(struct IORequest *)&TimerReq,0))
  538.         {
  539.             MasterTime=MASTERTIME;
  540.             SlaveTime=SLAVETIME;
  541.             TimerReq.tr_node.io_Message.mn_ReplyPort=TimerPort;
  542.             TimerReq.tr_node.io_Command=TR_ADDREQUEST;
  543.             TimerReq.tr_time.tv_secs=1;
  544.             TimerReq.tr_time.tv_micro=0;
  545.             TimerReq.tr_node.io_Error=0;
  546.             TimerReq.tr_node.io_Flags=0;
  547.             SendIO((struct IORequest *)&TimerReq);
  548.             return 1;
  549.         }
  550.     }
  551.     return 0;
  552. }
  553.  
  554. void RemInt()
  555. {
  556.     if(timerun) CloseDevice((struct IORequest *)&TimerReq);
  557.     if(TimerPort) DeletePort(TimerPort);
  558. }
  559.  
  560. void HandleCxMsg()
  561. {
  562.     while(cxmsg=(CxMsg *)GetMsg(broker_mp))
  563.     {
  564.         msgid  = CxMsgID(cxmsg);
  565.         msgtype= CxMsgType(cxmsg);
  566.         ReplyMsg((struct Message *)cxmsg);
  567.         switch(msgtype)
  568.         {
  569.             case CXM_IEVENT:
  570.                 switch(msgid)
  571.                 {
  572.                     case EVT_HOTKEY:
  573.                         LogFile(TYPE_HOTKEY,0);
  574.                         MasterTime=0;
  575.                         HDDriveOff(DRV_MASTER);
  576.                         SlaveTime=0;
  577.                         HDDriveOff(DRV_SLAVE);
  578.                         if(MainWnd)
  579.                         {
  580.                             CloseMainWindow();
  581.                             CloseDownScreen();
  582.                             SigWin=NULL;
  583.                         }
  584.                         break;
  585.                     case EVT_POPKEY:
  586.                         if(!MainWnd)
  587.                         {
  588.                             if(!SetupScreen())
  589.                             {
  590.                                 if(!OpenMainWindow())
  591.                                 {
  592.                                     SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  593.                                     GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  594.                                     GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  595.                                 }
  596.                             }
  597.                         }
  598.                         else
  599.                         {
  600.                             WindowToFront(MainWnd);
  601.                             ScreenToFront(Scr);
  602.                         }
  603.                         break;
  604.                 }
  605.                 break;
  606.             case CXM_COMMAND:
  607.                 switch(msgid)
  608.                 {
  609.                     case CXCMD_DISABLE:
  610.                         ActivateCxObj(broker,0L);
  611.                         break;
  612.                     case CXCMD_ENABLE:
  613.                         ActivateCxObj(broker,1L);
  614.                         break;
  615.                     case CXCMD_APPEAR:
  616.                         if(!MainWnd)
  617.                         {
  618.                             if(!SetupScreen())
  619.                             {
  620.                                 if(!OpenMainWindow())
  621.                                 {
  622.                                     SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  623.                                     GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  624.                                     GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  625.                                 }
  626.                             }
  627.                         }
  628.                         else
  629.                         {
  630.                             WindowToFront(MainWnd);
  631.                             ScreenToFront(Scr);
  632.                         }
  633.                         break;
  634.                     case CXCMD_DISAPPEAR:
  635.                         if(MainWnd)
  636.                         {
  637.                             CloseMainWindow();
  638.                             CloseDownScreen();
  639.                             SigWin=NULL;
  640.                         }
  641.                         break;
  642.                     case CXCMD_KILL:
  643.                     case CXCMD_UNIQUE:
  644.                         running=FALSE;
  645.                         break;
  646.                 }
  647.                 break;
  648.         }
  649.     }
  650. }
  651.  
  652. void RequestOK(char *napis)
  653. {
  654.     struct EasyStruct easyreq;
  655.     APTR bw=NULL;
  656.  
  657.     easyreq.es_StructSize=sizeof(struct EasyStruct);
  658.     easyreq.es_Flags=0;
  659.     easyreq.es_Title="About";
  660.     easyreq.es_TextFormat=napis;
  661.     easyreq.es_GadgetFormat="Ok";
  662.  
  663.     if(MainWnd) bw=BusyWindow(MainWnd);
  664.     EasyRequest(MainWnd,&easyreq,NULL,NULL);
  665.     if(bw) UnbusyWindow(bw);
  666. }
  667.  
  668. APTR BusyWindow(struct Window *Win)
  669. {
  670.     struct BusyWin *bw=NULL;
  671.  
  672.     if(Win)
  673.     {
  674.         if(bw=AllocVec(sizeof(struct BusyWin),MEMF_ANY))
  675.         {
  676.             bw->Win=Win;
  677.             InitRequester(&bw->Req);
  678.             Request(&bw->Req,bw->Win);
  679.             SetWindowPointer(bw->Win,WA_BusyPointer,TRUE,TAG_DONE);
  680.         }
  681.     }
  682.     return((APTR) bw);
  683. }
  684.  
  685. void UnbusyWindow(APTR bwp)
  686. {
  687.     struct BusyWin *bw;
  688.  
  689.     if(bwp)
  690.     {
  691.         bw=(struct BusyWin *)bwp;
  692.         EndRequest(&bw->Req,bw->Win);
  693.         SetWindowPointer(bw->Win,WA_Pointer,NULL,TAG_DONE);
  694.         FreeVec(bwp);
  695.     }
  696. }
  697.  
  698. void LogFile(UBYTE type,UBYTE hd)
  699. {
  700.     FILE *fh;
  701.     char texttime[100];
  702.     unsigned char clock[8];
  703.  
  704.     if(logfilestr[0])
  705.     {
  706.         if(fh=fopen(logfilestr,"a"))
  707.         {
  708.             getclk(clock);
  709.             sprintf(texttime,"%02ld-%02ld-%02ld %02ld:%02ld:%02ld",(ULONG)clock[3],(ULONG)clock[2],(ULONG)clock[1]+80,(ULONG)clock[4],(ULONG)clock[5],(ULONG)clock[6]);
  710.             switch(type)
  711.             {
  712.                 case TYPE_RUN:
  713.                     fprintf(fh,"%s  HDSleep started.\n",texttime);
  714.                     break;
  715.                 case TYPE_END:
  716.                     fprintf(fh,"%s  HDSleep exited.\n\n*********************\n\n",texttime);
  717.                     break;
  718. //            case TYPE_SPINUP:
  719. //                fprintf(fh,"%s  HD Spinup.\n",texttime);
  720. //                break;
  721.                 case TYPE_SPINDOWN:
  722.                     fprintf(fh,"%s  %s HD spindown after %ld seconds inactivity.\n",texttime,hd?"Slave":"Master",hd?SLAVETIME:MASTERTIME);
  723.                     break;
  724.                 case TYPE_HOTKEY:
  725.                     fprintf(fh,"%s  All HDs have been spindown by the user.\n",texttime);
  726.                     break;
  727.             }
  728.             fclose(fh);
  729.         }
  730.         switch(type)
  731.         {
  732.             case TYPE_SPINDOWN:
  733.             case TYPE_HOTKEY:
  734.                 Delay(3*50);        // Delay to write log
  735.                 break;
  736.         }
  737.     }
  738. }
  739.